Skip to content

Fix unclear PPL error message for empty mapping on wildcard indices - #5609

Open
anohedr wants to merge 3 commits into
opensearch-project:mainfrom
anohedr:feature/unclear_ppl_err_msg_4968
Open

Fix unclear PPL error message for empty mapping on wildcard indices#5609
anohedr wants to merge 3 commits into
opensearch-project:mainfrom
anohedr:feature/unclear_ppl_err_msg_4968

Conversation

@anohedr

@anohedr anohedr commented Jul 6, 2026

Copy link
Copy Markdown

Description

Improves the error message returned when an index has an empty mapping. This change makes the error clearer and more actionable for users while preserving the existing behavior. Unit tests have been updated to verify the new error message.

Related Issues

Resolves #[4872]

Check List

  • New functionality includes testing.
  • New functionality has been documented.
  • New functionality has javadoc added.
  • New functionality has a user manual doc added.
  • New PPL command checklist all confirmed.
  • API changes companion pull request created.
  • Commits are signed per the DCO using --signoff or -s.
  • Public documentation issue/PR created.

By submitting this pull request, I confirm that my contribution is made under the terms of the Apache 2.0 license.
For more information on following Developer Certificate of Origin and signing off your commits, please check here.

@github-actions

github-actions Bot commented Jul 6, 2026 •
edited
Loading

Copy link
Copy Markdown
Contributor

PR Reviewer Guide 🔍

(Review updated until commit 879940e)

Here are some key observations to aid the review process:

🧪 PR contains tests
🔒 No security concerns identified
✅ No TODO sections
🔀 No multiple PR themes
⚡ Recommended focus areas for review

Possible Issue

The pattern detection logic treats a single string containing a comma (e.g., "index1,index2") as a non-pattern, but OpenSearch interprets comma-separated values within a single string as multiple indices. This mismatch causes the error message to omit the "compatible mapping" hint when it should be included, misleading users who pass comma-separated index names as a single argument.

 
|| Arrays.stream(exprs)
    .filter(e -> e != null)
    .anyMatch(
        e ->
            e.contains("*")
                || e.contains("?")
                || e.startsWith("<")
                || e.startsWith("-")
                || e.equals("_all"));

@github-actions

github-actions Bot commented Jul 6, 2026 •
edited
Loading

Copy link
Copy Markdown
Contributor

PR Code Suggestions ✨

Latest suggestions up to 879940e

Explore these optional code suggestions:

CategorySuggestion                                                                                                                                    Impact
General
Remove incorrect hyphen pattern check

The pattern detection logic treats a leading hyphen (-) as a wildcard pattern
indicator, but in OpenSearch index expressions, a leading hyphen denotes exclusion
(e.g., index,-excluded). This can cause false positives when checking for patterns.
Consider removing the e.startsWith("-") condition or refining the logic to
distinguish between exclusion syntax and actual pattern indicators.*

opensearch/src/main/java/org/opensearch/sql/opensearch/client/OpenSearchClient.java [144-154]

 boolean isPattern =
     exprs.length > 1
         || Arrays.stream(exprs)
             .filter(e -> e != null)
             .anyMatch(
                 e ->
                     e.contains("*")
                         || e.contains("?")
                         || e.startsWith("<")
-                        || e.startsWith("-")
                         || e.equals("_all"));
Suggestion importance[1-10]: 7

__

Why: The suggestion correctly identifies that e.startsWith("-") may cause false positives in pattern detection. In OpenSearch, a leading hyphen indicates exclusion syntax rather than a wildcard pattern. Removing this check would improve the accuracy of pattern detection, though the impact is moderate since exclusion syntax is less commonly used alone.

Medium

Previous suggestions

Suggestions up to commit 21ff0fc
CategorySuggestion                                                                                                                                    Impact
Possible issue
Avoid false pattern detection for hyphenated names

The pattern detection logic treats a leading hyphen (-) as a wildcard pattern
indicator, but this conflicts with date-based index names (e.g., logs-2024-01-01)
which are common and not patterns. Consider checking for exclusion syntax more
precisely (e.g., -index without other characters) or removing this check to avoid
false positives.

opensearch/src/main/java/org/opensearch/sql/opensearch/client/OpenSearchClient.java [144-154]

 boolean isPattern =
     exprs.length > 1
         || Arrays.stream(exprs)
             .filter(e -> e != null)
             .anyMatch(
                 e ->
                     e.contains("*")
                         || e.contains("?")
                         || e.startsWith("<")
-                        || e.startsWith("-")
                         || e.equals("_all"));
Suggestion importance[1-10]: 7

__

Why: The suggestion correctly identifies that e.startsWith("-") can cause false positives for date-based index names like logs-2024-01-01. However, the check is intended to detect exclusion patterns (e.g., -excluded_index), which are valid OpenSearch syntax. The suggestion to remove this check entirely may miss legitimate exclusion patterns, but the concern about false positives is valid and warrants careful consideration.

Medium
Suggestions up to commit 5e50c14
CategorySuggestion                                                                                                                                    Impact
General
Fix pattern detection for exclusions

The pattern detection logic treats any expression starting with - as a pattern, but
- is used for exclusions in multi-index patterns (e.g., index,-excluded). A single
expression starting with - (like -myindex) is invalid and should not be classified
as a pattern requiring the "compatible mapping" hint.*

opensearch/src/main/java/org/opensearch/sql/opensearch/client/OpenSearchClient.java [144-154]

 boolean isPattern =
     exprs.length > 1
         || Arrays.stream(exprs)
             .filter(e -> e != null)
             .anyMatch(
                 e ->
                     e.contains("*")
                         || e.contains("?")
                         || e.startsWith("<")
-                        || e.startsWith("-")
                         || e.equals("_all"));
Suggestion importance[1-10]: 7

__

Why: The suggestion correctly identifies that a single expression starting with - (like -myindex) is invalid and shouldn't trigger the "compatible mapping" hint. However, the logic exprs.length > 1 already handles multi-index patterns where exclusions are valid, so removing the e.startsWith("-") check is appropriate for single-expression cases.

Medium
Suggestions up to commit 8f53d9a
CategorySuggestion                                                                                                                                    Impact
General
Remove redundant ErrorReport catch block

Catching and re-throwing ErrorReport is unnecessary since ErrorReport extends
RuntimeException. The existing catch block for generic Exception will not catch
ErrorReport anyway due to the order. Remove this redundant catch block to simplify
the exception handling flow.

opensearch/src/main/java/org/opensearch/sql/opensearch/client/OpenSearchNodeClient.java [117-119]

-} catch (ErrorReport e) {
-  throw e;
 } catch (Exception e) {
Suggestion importance[1-10]: 4

__

Why: The catch block for ErrorReport appears redundant since it only re-throws the exception. However, it serves to preserve the specific ErrorReport type before the generic Exception handler wraps it in IllegalStateException. Removing it would change exception handling behavior, though the impact is minor since ErrorReport extends RuntimeException.

Low
Fix pattern detection for multi-index queries

The pattern detection logic treats a comma within a single string as a pattern
indicator, but commas are also used to separate multiple index names in a single
argument. This can cause false positives where legitimate multi-index queries
without wildcards are incorrectly flagged as patterns. Consider checking if the
array contains multiple elements OR if any single element contains pattern syntax.

opensearch/src/main/java/org/opensearch/sql/opensearch/client/OpenSearchClient.java [134-146]

 String[] exprs = indexExpression != null ? indexExpression : new String[0];
 String joined = String.join(",", exprs);
 boolean isPattern =
-    Arrays.stream(exprs)
-        .filter(e -> e != null)
-        .anyMatch(
-            e ->
-                e.contains("*")
-                    || e.contains("?")
-                    || e.contains(",")
-                    || e.startsWith("<")
-                    || e.startsWith("-")
-                    || e.equals("_all"));
+    exprs.length > 1
+        || Arrays.stream(exprs)
+            .filter(e -> e != null)
+            .anyMatch(
+                e ->
+                    e.contains("*")
+                        || e.contains("?")
+                        || e.contains(",")
+                        || e.startsWith("<")
+                        || e.startsWith("-")
+                        || e.equals("_all"));
Suggestion importance[1-10]: 3

__

Why: The suggestion identifies a potential issue where exprs.length > 1 could help distinguish multi-index queries, but the current logic already handles commas within strings as pattern indicators (which is correct per OpenSearch syntax). The test at line 310-314 validates this behavior. The suggestion may introduce unintended changes to the error message logic without clear benefit.

Low
Suggestions up to commit ae77f2a
CategorySuggestion                                                                                                                                    Impact
General
Fix pattern detection for hyphenated names

The pattern detection logic may incorrectly classify indices with hyphens in their
names (e.g., my-index) as patterns because it checks e.startsWith("-"). This check
is intended for exclusion patterns but will match any index name containing a
leading hyphen. Consider checking for exclusion syntax more precisely or documenting
this behavior.

opensearch/src/main/java/org/opensearch/sql/opensearch/client/OpenSearchClient.java [135-144]

 boolean isPattern =
     Arrays.stream(indexExpression)
         .filter(e -> e != null)
         .anyMatch(
             e ->
                 e.contains("*")
                     || e.contains("?")
                     || e.startsWith("<")
-                    || e.startsWith("-")
+                    || (e.startsWith("-") && e.length() > 1 && !Character.isLetterOrDigit(e.charAt(1)))
                     || e.equals("_all"));
Suggestion importance[1-10]: 8

__

Why: The suggestion correctly identifies a critical bug where e.startsWith("-") would incorrectly classify normal index names like my-index as patterns. The improved code adds a check to distinguish between exclusion patterns (e.g., -excluded*) and regular hyphenated names, preventing false positives that would show incorrect error messages to users.

Medium

@github-actions

github-actions Bot commented Jul 7, 2026

Copy link
Copy Markdown
Contributor

Persistent review updated to latest commit 8f53d9a

@github-actions

github-actions Bot commented Jul 7, 2026

Copy link
Copy Markdown
Contributor

Persistent review updated to latest commit 5e50c14

@RyanL1997 RyanL1997 added the enhancement New feature or request label Jul 7, 2026
@github-actions

github-actions Bot commented Jul 15, 2026

Copy link
Copy Markdown
Contributor

Persistent review updated to latest commit 21ff0fc

@github-actions

github-actions Bot commented Jul 21, 2026

Copy link
Copy Markdown
Contributor

Persistent review updated to latest commit 5618a2e

@anohedr
anohedr force-pushed the feature/unclear_ppl_err_msg_4968 branch from 5618a2e to 879940e Compare July 22, 2026 04:42
@github-actions

github-actions Bot commented Jul 22, 2026

Copy link
Copy Markdown
Contributor

Persistent review updated to latest commit 879940e

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Reviewers

@ps48 ps48 Awaiting requested review from ps48 ps48 is a code owner
@joshuali925 joshuali925 Awaiting requested review from joshuali925 joshuali925 is a code owner
@dai-chen dai-chen Awaiting requested review from dai-chen dai-chen is a code owner
@mengweieric mengweieric Awaiting requested review from mengweieric mengweieric is a code owner
@vamsimanohar vamsimanohar Awaiting requested review from vamsimanohar vamsimanohar is a code owner
@Swiddis Swiddis Awaiting requested review from Swiddis Swiddis is a code owner
@penghuo penghuo Awaiting requested review from penghuo penghuo is a code owner
@anirudha anirudha Awaiting requested review from anirudha anirudha is a code owner
@acarbonetto acarbonetto Awaiting requested review from acarbonetto acarbonetto is a code owner
@ykmr1224 ykmr1224 Awaiting requested review from ykmr1224 ykmr1224 is a code owner
@LantaoJin LantaoJin Awaiting requested review from LantaoJin LantaoJin is a code owner
@noCharger noCharger Awaiting requested review from noCharger noCharger is a code owner
@qianheng-aws qianheng-aws Awaiting requested review from qianheng-aws qianheng-aws is a code owner
@yuancu yuancu Awaiting requested review from yuancu yuancu is a code owner
@RyanL1997 RyanL1997 Awaiting requested review from RyanL1997 RyanL1997 is a code owner
@ahkcs ahkcs Awaiting requested review from ahkcs ahkcs is a code owner
@songkant-aws songkant-aws Awaiting requested review from songkant-aws songkant-aws is a code owner

At least 1 approving review is required to merge this pull request.

Assignees

No one assigned

Labels

enhancement New feature or request

Projects

None yet

Milestone

No milestone

Development

Successfully merging this pull request may close these issues.

2 participants

@anohedr @RyanL1997